home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / tools / netzwerk / tcp-ip / ipdial_v1.9 / ipdial.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-26  |  24.8 KB  |  1,145 lines
  1. /**
  2. ***  IPDial     Script program for initializing a SLIP connection
  3. ***  Copyright  (C)   1994    Jochen Wiedmann
  4. ***
  5. ***  This program is free software; you can redistribute it and/or modify
  6. ***  it under the terms of the GNU General Public License as published by
  7. ***  the Free Software Foundation; either version 2 of the License, or
  8. ***  (at your option) any later version.
  9. ***
  10. ***  This program is distributed in the hope that it will be useful,
  11. ***  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ***  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ***  GNU General Public License for more details.
  14. ***
  15. ***  You should have received a copy of the GNU General Public License
  16. ***  along with this program; if not, write to the Free Software
  17. ***  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. ***
  19. ***
  20. ***  This is the main part of the program.
  21. ***
  22. ***
  23. ***  Computer: Amiga 1200                       Compiler: Dice 3.01
  24. ***
  25. ***  Author:    Jochen Wiedmann
  26. ***             Am Eisteich 9
  27. ***             72555 Metzingen
  28. ***             Germany
  29. ***
  30. ***             Phone: (+0049) 7123 / 14881
  31. ***             Internet: wiedmann@neckar-alb.de
  32. ***
  33. ***
  34. ***  History:   V 1.1   23.11.94        Initial version
  35. ***
  36. ***             V 1.2   27.02.95        Added terminal mode
  37. ***                                     Now using ReadArgs() for
  38. ***                                     command line parsing.
  39. ***
  40. ***             V 1.3   09.03.95        Added environment variable
  41. ***                                     aupport to "send" command.
  42. ***                                     Added unit support.
  43. ***
  44. ***             V 1.4   21.04.95        Added "system" command.
  45. ***                                     Added environment variable
  46. ***                                     support to "echo" command.
  47. ***                                     Terminal mode now converts
  48. ***                                     LF to CR/LF, so that modem
  49. ***                                     recognizes commands.
  50. ***                                     (Let's hope, that will still
  51. ***                                     work for entering passwords. :-(
  52. ***
  53. ***             V 1.5   30.04.95        Added "scan" command.
  54. ***
  55. ***             V 1.6   26.06.95        "delay" command supporting
  56. ***                                     ticks; ParseString()
  57. ***                                     supporting octal characters;
  58. ***                                     "wait" command using
  59. ***                                     ParseString()
  60. ***                                     (All Suggested by Will Bow.)
  61. ***
  62. ***                                     Fixed bug in SerialSend():
  63. ***                                     *.io_Device = *.io_Unit
  64. ***
  65. ***             V 1.7   22.07.95        Added ECHO, RAW and EOF options
  66. ***                                     to "terminal" command.
  67. ***                                     (Suggested by Klaus Heinz.)
  68. ***
  69. ***                                     Added BAUD option to command
  70. ***                                     line.
  71. ***
  72. ***                                     Added "setvar" command.
  73. ***
  74. ***             v 1.8   24.11.95        Put a 10 tick delay after the
  75. ***                                     DoIO() call in DeviceIODo()
  76. ***
  77. ***             v 1.9   29.11.95        Broke Delay when using decimals
  78. ***                                     Fixed it in this release.
  79. **/
  80. #define VERSION     1
  81. #define REVISION    9
  82. #define VSTRING     "IPDial 1.9 (29.11.95)"
  83. #define VERSTAG     "\0$VER: IPDial 1.9 (29.11.95)"
  84. /**
  85. ***  Include files
  86. **/
  87. #include "IPDial.h"
  88. #include <ctype.h>
  89. #include <clib/alib_protos.h>
  90. /**
  91. ***  This structure describes one command. All commands are stored
  92. ***  in a table at the end of the file.
  93. **/
  94. struct ScriptLine;
  95. typedef VOID (*CommandFunc) (struct ScriptLine *);
  96. struct Command
  97. { 
  98.   CommandFunc Func;
  99.   STRPTR Name;
  100. };
  101. /**
  102. ***  Each line of the script file is stored in a structure like below.
  103. **/
  104. struct ScriptLine
  105. { 
  106.   struct MinNode mn;
  107.   ULONG Num;
  108.   CommandFunc CommFunc;
  109.   STRPTR Label;
  110.   STRPTR Args;
  111. };
  112. /**
  113. ***  Global variables
  114. **/
  115. LONG StatusVar;
  116.  
  117. struct MinList ScriptLineList;
  118.  
  119. struct ScriptLine *CurrentScriptLine;
  120.  
  121. const UBYTE VersTag [] = VERSTAG;
  122. const UBYTE VString [] = VSTRING;
  123.  
  124. ULONG EchoMode = FALSE;
  125. ULONG VerboseMode = FALSE;
  126.  
  127. STRPTR SerialDeviceName = NULL;
  128.  
  129. struct RDArgs *MainRDArgs = NULL;
  130. /**
  131. ***  This function is used to skip blanks.
  132. **/
  133. STRPTR SkipBlanks(const UBYTE *ptr)
  134. { 
  135.   while(*ptr == ' '  ||  *ptr == '\t')
  136.   { 
  137.     ++ptr;
  138.   }
  139.   return((STRPTR) ptr);
  140. }
  141. /**
  142. ***  This function is used to parse a string for characters
  143. ***  like '\r' or '\n'. $VAR or ${VAR} may be used to insert
  144. ***  the value of environment variable VAR, $$ may be used to
  145. ***  insert the '$' character itself, likewise \\.
  146. ***
  147. ***  Returns a pointer to a string allocated with malloc().
  148. ***  It is the task of the caller, to free() this string.
  149. **/
  150. STRPTR ParseString(const UBYTE *ptr)
  151. { 
  152.   STRPTR result;
  153.   STATIC APTR parseBuffer = NULL;
  154.   /**
  155.   ***  Be sure, that buffer is valid.
  156.   **/
  157.   if (!parseBuffer  &&  !(parseBuffer = BufferCreate()))
  158.   { 
  159.     perror("malloc");
  160.     exit(10);
  161.   }
  162.   /**
  163.   ***  Clear the buffer.
  164.   **/
  165.   BufferClear(parseBuffer);
  166.  
  167.   while(*ptr)
  168.   { 
  169.     if (*ptr == '\\')
  170.     { 
  171.       ++ptr;
  172.       switch(*ptr)
  173.       { 
  174.         case 'r':
  175.             BufferExtend(parseBuffer, (STRPTR) "\r", 1);
  176.             break;
  177.           case 'n':
  178.             BufferExtend(parseBuffer, (STRPTR) "\n", 1);
  179.             break;
  180.           case '0':
  181.           case '1':
  182.           case '2':
  183.           case '3':
  184.           case '4':
  185.           case '5':
  186.           case '6':
  187.           case '7':
  188.             { 
  189.             char c;
  190.  
  191.               c = *ptr - '0';
  192.               if (ptr[1] >= '0'  &&  ptr[1] <= '7')
  193.               { 
  194.               c = (c << 3) + *(++ptr) - '0';
  195.                 if (ptr[1] >= '0'  &&  ptr[2] <= '7')
  196.                 { 
  197.                 c = (c << 3) + *(++ptr) - '0';
  198.                 }
  199.               }
  200.               BufferExtend(parseBuffer, (STRPTR) &c, 1);
  201.             }
  202.             break;
  203.           default:
  204.             BufferExtend(parseBuffer, ptr, 1);
  205.             break;
  206.       }
  207.       ++ptr;
  208.     }
  209.     else if (*ptr == '$')
  210.     { 
  211.       ++ptr;
  212.       if (*ptr == '$')
  213.       { 
  214.         BufferExtend(parseBuffer, (STRPTR) "$", 1);
  215.           ++ptr;
  216.       }
  217.       else
  218.       { 
  219.         char *varName;
  220.           const char* varPtr;
  221.           size_t varLen = 0;
  222.  
  223.           if (*ptr == '{')
  224.           { 
  225.           ++ptr;
  226.             varPtr = (const char*) ptr;
  227.             while (*ptr && *ptr != '}')
  228.             { 
  229.             ++ptr;
  230.               ++varLen;
  231.             }
  232.             if (*ptr == '}')
  233.             { 
  234.             ++ptr;
  235.             }
  236.           }
  237.           else
  238.           { 
  239.           varPtr = (const char*) ptr;
  240.             while (*ptr  &&  isalnum(*ptr))
  241.             { 
  242.             ++ptr;
  243.               ++varLen;
  244.             }
  245.           }
  246.  
  247.           if (!(varName = malloc(varLen + 1)))
  248.           { 
  249.           perror("malloc");
  250.             exit(10);
  251.           }
  252.           strncpy(varName, varPtr, varLen);
  253.           varName[varLen] = '\0';
  254.  
  255.           if ((varPtr = getenv(varName)))
  256.           { 
  257.           BufferExtend(parseBuffer, (STRPTR) varPtr, strlen(varPtr));
  258.           }
  259.       }
  260.     }
  261.     else
  262.     { 
  263.       BufferExtend(parseBuffer, ptr, 1);
  264.       ++ptr;
  265.     }
  266.   }
  267.  
  268.   BufferExtend(parseBuffer, (STRPTR) "", 1);
  269.  
  270.   if (!(result = (STRPTR) strdup((char*) BufferBuffer(parseBuffer))))
  271.   { 
  272.     perror("malloc");
  273.     exit(10);
  274.   }
  275.  
  276.   return(result);
  277. }
  278. /**
  279. ***  This is an empty function. Just to allow lines with labels only.
  280. **/
  281. VOID NoneFunc(struct ScriptLine *line)
  282. {
  283. }
  284. /**
  285. ***  This is the echo function.
  286. **/
  287. VOID EchoFunc(struct ScriptLine *line)
  288. { 
  289.   STRPTR *args;
  290.   int i;
  291.  
  292.   if (!StrReadArgs(line->Args, (LONG *) &args, (STRPTR) "ARGS/M"))
  293.   { 
  294.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  295.     exit(10);
  296.   }
  297.  
  298.   for(i = 0;  *args;  ++i, ++args)
  299.   { 
  300.     char *str;
  301.  
  302.     if (i)
  303.     { 
  304.       putchar(' ');
  305.     }
  306.     str = (char*) ParseString(*args);
  307.     fputs((char *) str, stdout);
  308.     fflush(stdout);
  309.     free(str);
  310.   }
  311. }
  312. /**
  313. ***  This is the device function.
  314. **/
  315. VOID DeviceFunc(struct ScriptLine *line)
  316. { 
  317.   struct
  318.   { 
  319.     STRPTR Device;
  320.     STRPTR Protocol;
  321.     LONG *Unit;
  322.   } args;
  323.  
  324.   if (SerialDeviceName)
  325.   { 
  326.     fprintf(stderr, "Line %ld: Device already open, ignoring.\n", line->Num);
  327.   }
  328.  
  329.   args.Unit = NULL;
  330.   args.Device = NULL;
  331.   args.Protocol = NULL;
  332.  
  333.   if (!StrReadArgs(line->Args, (LONG *) &args,
  334.           (STRPTR) "DEVICE,PROTOCOL,UNIT/K/N"))
  335.   { 
  336.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  337.     exit(10);
  338.   }
  339.  
  340.   if (!args.Device)
  341.   { 
  342.     fprintf(stderr, "Line %ld: Missing device name.\n", line->Num);
  343.     exit(10);
  344.   }
  345.   if (!(SerialDeviceName = (STRPTR) strdup((char *) args.Device)))
  346.   { 
  347.     perror("malloc");
  348.     exit(10);
  349.   }
  350.  
  351.   if (VerboseMode)
  352.   { 
  353.     printf("DeviceFunc: Opening %s.\n", args.Device);
  354.   }
  355.  
  356.   if (!SerialOpen(args.Device, args.Protocol, args.Unit ? *args.Unit : 0))
  357.   { 
  358.     fprintf(stderr, "Line %ld: Unknown protocol.\n", line->Num);
  359.     exit(10);
  360.   }
  361. }
  362. /**
  363. ***  This function is used to set the serial.device parameters.
  364. **/
  365. VOID SetFunc(struct ScriptLine *line)
  366. { 
  367.   struct
  368.   { 
  369.     ULONG *Baud;
  370.     ULONG *DataBits;
  371.     ULONG *StopBits;
  372.     ULONG *BufSize;
  373.     STRPTR Parity;
  374.     STRPTR Protocol;
  375.   } args;
  376.  
  377.   if (!SerialDeviceName)
  378.   { 
  379.     fprintf(stderr, "Line %ld: Must open serial.device first.\n", line->Num);
  380.     exit(10);
  381.   }
  382.  
  383.   args.Baud = NULL;
  384.   args.DataBits = NULL;
  385.   args.StopBits = NULL;
  386.   args.BufSize = NULL;
  387.   args.Parity = NULL;
  388.   args.Protocol = NULL;
  389.  
  390.   if (!(StrReadArgs(line->Args, (LONG *) &args,
  391.           (STRPTR) "BAUD/K/N,DATABITS/K/N,STOPBITS/K/N,BUFSIZE/K/N,"
  392.           "PARITY/K,PROTOCOL/K")))
  393.   { 
  394.     fprintf(stderr, "Line %ld: Argument or memory error.\n", line->Num);
  395.     exit(10);
  396.   }
  397.  
  398.   if (args.Baud)
  399.   { 
  400.     SerialSetBaud(*args.Baud);
  401.   }
  402.   if (args.DataBits)
  403.   { 
  404.     SerialSetDataBits(*args.DataBits);
  405.   }
  406.   if (args.StopBits)
  407.   { 
  408.     SerialSetStopBits(*args.StopBits);
  409.   }
  410.   if (args.BufSize)
  411.   { 
  412.     SerialSetBufSize(*args.BufSize);
  413.   }
  414.   if (args.Parity)
  415.   {
  416.     if (!SerialSetParity(args.Parity))
  417.     { 
  418.       fprintf(stderr, "Line %ld: Unknown parity.\n", line->Num);
  419.       exit(10);
  420.     }
  421.   }
  422.   if (args.Protocol)
  423.   {
  424.     if (!SerialSetProtocol(args.Protocol))
  425.     { 
  426.       fprintf(stderr, "Line %ld: Unknown protocol.\n", line->Num);
  427.       exit(10);
  428.     }
  429.   }
  430.  
  431.   if (VerboseMode)
  432.   { 
  433.     printf("SetFunc: %s Parameters modified:\n\n", SerialDeviceName);
  434.     SerialShowParms();
  435.   }
  436. }
  437. /**
  438. ***  This function shows the serial.device parameters.
  439. **/
  440. VOID ShowParmsFunc(struct ScriptLine *line)
  441. { 
  442.   if (!SerialDeviceName)
  443.   { 
  444.     fprintf(stderr, "Line %ld: Must open serial.device first.\n", line->Num);
  445.     exit(10);
  446.   }
  447.  
  448.   printf("%s Parameters:\n\n", SerialDeviceName);
  449.   SerialShowParms();
  450. }
  451. /**
  452. ***  This function sends a string to the serial.device.
  453. **/
  454. VOID SendFunc(struct ScriptLine *line)
  455. { 
  456.   STRPTR *args;
  457.  
  458.   if (VerboseMode)
  459.   { 
  460.     fflush(stdout);
  461.     printf("\nSendFunc: Sending: ");
  462.   }
  463.  
  464.  
  465.   if (!SerialDeviceName)
  466.   { 
  467.     fprintf(stderr, "Line %ld: Must open serial.device first.\n", line->Num);
  468.     exit(10);
  469.   }
  470.  
  471.   if (!StrReadArgs(line->Args, (LONG *) &args, (STRPTR) "ARGS/M"))
  472.   { 
  473.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  474.     exit(10);
  475.   }
  476.  
  477.   for(;  *args;  args++)
  478.   { 
  479.     STRPTR send = ParseString(*args);
  480.  
  481.     if (VerboseMode)
  482.       printf(" %s \n", send);
  483.       
  484.     SerialSend(send, strlen((char *) send));
  485.     free(send);
  486.   }
  487.  
  488.   if (VerboseMode)
  489.   { 
  490.     printf("\n");
  491.   }
  492. }
  493. /**
  494. ***  This is similar to "if".
  495. **/
  496. VOID DoGoto(STRPTR Label, int Num)
  497. { 
  498.   struct ScriptLine *sl;
  499.  
  500.   for(sl = (struct ScriptLine *) ScriptLineList.mlh_Head;
  501.         sl->mn.mln_Succ;
  502.         sl = (struct ScriptLine *) sl->mn.mln_Succ)
  503.   { 
  504.     if (sl->Label  &&  strcmp((char *) sl->Label, (char *) Label) == 0)
  505.     { 
  506.       CurrentScriptLine = (struct ScriptLine *) sl->mn.mln_Pred;
  507.       return;
  508.     }
  509.   }
  510.  
  511.   fprintf(stderr, "Line %d: Unknown label.\n", Num);
  512.   exit(10);
  513. }
  514. VOID OnFunc(struct ScriptLine *line)
  515. { STRPTR ptr = line->Args;
  516.  
  517.   if (strnicmp((char *) ptr, "status", 6) == 0)
  518.   { 
  519.     ptr = SkipBlanks(ptr+6);
  520.     if (strnicmp((char *) ptr, "goto", 4) == 0)
  521.     { 
  522.       STRPTR *labels;
  523.       int i;
  524.  
  525.       if (!StrReadArgs(ptr+4, (LONG *) &labels, (STRPTR) "LABELS/M"))
  526.       { 
  527.         fprintf(stderr, "Line %ld: Memory error.\n", line->Num);
  528.           exit(10);
  529.       }
  530.       for (i = -1;  *labels;  ++i, ++labels)
  531.       { 
  532.         if (i == StatusVar)
  533.           { 
  534.           DoGoto(*labels, line->Num);
  535.             return;
  536.           }
  537.       }
  538.       return;
  539.     }
  540.   }
  541.  
  542.   fprintf(stderr, "Line %ld: Condition syntax.", line->Num);
  543.   exit(10);
  544. }
  545. /**
  546. ***  This function waits for certain strings.
  547. **/
  548. VOID WaitFunc(struct ScriptLine *line)
  549. { 
  550.   struct
  551.   { 
  552.     STRPTR *WaitArgs;
  553.     ULONG *TimeOut;
  554.   } args;
  555.   STRPTR* parsedArgs;
  556.   LONG TimeOut;
  557.   int i = 0;
  558.  
  559.   if(VerboseMode)
  560.     printf("\nWaitFunc: line->Args %s \n",line->Args);
  561.     
  562.   if (!SerialDeviceName)
  563.   { 
  564.     fprintf(stderr, "Line %ld: Must open serial.device first.\n", line->Num);
  565.     exit(10);
  566.   }
  567.  
  568.   args.WaitArgs = NULL;
  569.   args.TimeOut = NULL;
  570.  
  571.   if (!(StrReadArgs(line->Args, (LONG *)&args, (STRPTR) "ARGS/M,TIMEOUT/N/K")))
  572.   { 
  573.     fprintf(stderr, "Line %ld: Argument or memory error.\n", line->Num);
  574.     exit(10);
  575.   }
  576.  
  577.   if (!args.WaitArgs)
  578.   { 
  579.     fprintf(stderr, "Line %ld: Missing argument.\n", line->Num);
  580.     exit(10);
  581.   }
  582.   if (!args.TimeOut)
  583.   { 
  584.     fprintf(stderr, "Line %ld: Missing timeout argument.\n", line->Num);
  585.     exit(10);
  586.   }
  587.   TimeOut = *args.TimeOut;
  588.  
  589.  
  590.   while (args.WaitArgs[i])
  591.   { 
  592.     ++i;
  593.   }
  594.  
  595.   if (!(parsedArgs = malloc(sizeof(STRPTR) * (i+1))))
  596.   { 
  597.     perror("malloc");
  598.     exit(10);
  599.   }
  600.  
  601.   for (i = 0;  args.WaitArgs[i];  i++)
  602.   { 
  603.     parsedArgs[i] = ParseString(args.WaitArgs[i]);
  604.   }
  605.   parsedArgs[i] = NULL;
  606.    
  607.   StatusVar = SerialWait(parsedArgs, TimeOut);
  608. }
  609. /**
  610. ***  The delay function waits for a certain amount of time.
  611. **/
  612. VOID DelayFunc(struct ScriptLine *line)
  613. { 
  614.   ULONG tics;
  615.   double ftics;
  616.   
  617.   if (VerboseMode)
  618.     printf("DelayFunc: line->Args: %s\n",(char *) line->Args);
  619.     
  620.   ftics = (atof((char *) line->Args) * 50);
  621.  
  622.   tics = (ULONG)ceil(ftics);
  623.   
  624.   if (tics == 0)
  625.   { 
  626.     fprintf(stderr, "DelayFunc: Line %ld: Missing argument.\n", line->Num);
  627.     exit(10);
  628.   }
  629.  
  630.   Delay(tics);
  631. }
  632. /**
  633. ***  And this is the Exit function.
  634. **/
  635. VOID ExitFunc(struct ScriptLine *line)
  636.  
  637. { 
  638.   LONG result = atol((char *) line->Args);
  639.   exit(result);
  640. }
  641. /**
  642. ***  The Goto command
  643. **/
  644. VOID GotoFunc(struct ScriptLine *line)
  645. { 
  646.   STRPTR Label;
  647.  
  648.   if (!(StrReadArgs(line->Args, (LONG *) &Label, (STRPTR) "LABEL/A")))
  649.   { 
  650.     fprintf(stderr, "Line %ld: Missing argument or memory error.\n",
  651.               line->Num);
  652.     exit(10);
  653.   }
  654.   DoGoto(Label, line->Num);
  655. }
  656. /**
  657. ***  This function enters terminal mode.
  658. **/
  659. VOID TermFunc(struct ScriptLine *line)
  660. { 
  661.   struct
  662.   { 
  663.     STRPTR eof;
  664.     ULONG noecho;
  665.     ULONG raw;
  666.   } args;
  667.  
  668.   args.eof = NULL;
  669.   args.noecho = FALSE;
  670.   args.raw = FALSE;
  671.  
  672.   if (!StrReadArgs(line->Args, (LONG *) &args, (STRPTR) "EOF,NOECHO/S,RAW/S"))
  673.   { 
  674.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  675.     exit(10);
  676.   }
  677.  
  678.   if (args.eof) 
  679.   {
  680.     args.eof = ParseString(args.eof);
  681.   }
  682.   SerialTerminal(args.eof, !args.noecho, !args.raw);
  683. }
  684. /**
  685. ***  Execute external commands.
  686. **/
  687. VOID SystemFunc(struct ScriptLine *line)
  688. { 
  689.   STRPTR *args;
  690.   int i, result;
  691.   char *cmd;
  692.   STATIC APTR systemBuffer = NULL;
  693.  
  694.   /**
  695.   ***  Initialize buffer.
  696.   **/
  697.   if (!systemBuffer  &&  !(systemBuffer = BufferCreate()))
  698.   { 
  699.     perror("malloc");
  700.     exit(10);
  701.   }
  702.   BufferClear(systemBuffer);
  703.  
  704.  
  705.   if (!StrReadArgs(line->Args, (LONG *) &args, (STRPTR) "ARGS/M"))
  706.   { 
  707.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  708.     exit(10);
  709.   }
  710.  
  711.   for(i = 0;  *args;  ++i, ++args)
  712.   { 
  713.     char *str;
  714.  
  715.     if (i)
  716.     { 
  717.       BufferExtend(systemBuffer, (STRPTR) " ", 1);
  718.     }
  719.     str = (char*) ParseString(*args);
  720.     BufferExtend(systemBuffer, (STRPTR) str, strlen(str));
  721.     free(str);
  722.   }
  723.   cmd = (char*) BufferBuffer(systemBuffer);
  724.  
  725.   if (VerboseMode)
  726.   { 
  727.     printf("Executing command: \"%s\"\n", cmd);
  728.   }
  729.   result = system(cmd);
  730.   if (result)
  731.   { 
  732.     if (result > 1  &&  result < 10)  /* Warning */
  733.     { 
  734.       if (VerboseMode)
  735.       { 
  736.         printf("Returned %d.\n", result);
  737.       }
  738.     }
  739.     else
  740.     { printf("Error: Command \"%s\" returned %d.\n", cmd, result);
  741.       exit(result);
  742.     }
  743.   }
  744. }  
  745. /**
  746. ***  Scan the buffer received by the last "wait" command.
  747. **/
  748. VOID ScanFunc(struct ScriptLine *line)
  749. { 
  750.   struct
  751.   { 
  752.     STRPTR format;
  753.     ULONG global;
  754.     ULONG save;
  755.   } args;
  756.   ULONG flags;
  757.  
  758.   args.format = NULL;
  759.   args.global = FALSE;
  760.   args.save = FALSE;
  761.  
  762.   if (!(StrReadArgs(line->Args, (LONG *) &args,
  763.           (STRPTR) "FORMAT/A,GLOBAL/S,SAVE/S")))
  764.   { 
  765.     fprintf(stderr, "Line %ld: Argument or memory error.\n", line->Num);
  766.     exit(10);
  767.   }
  768.  
  769.   flags = 0;
  770.   if (args.save)
  771.   { 
  772.     args.global = TRUE;
  773.     flags |= GVF_SAVE_VAR;
  774.   }
  775.   if (args.global)
  776.   { 
  777.     flags |= GVF_GLOBAL_ONLY;
  778.   }
  779.   else
  780.   { 
  781.     flags |= GVF_LOCAL_ONLY;
  782.   }
  783.  
  784.   StatusVar = Vsscanf(SerialWaitBuffer(), args.format, flags);
  785. }
  786. /**
  787. ***  The SetVar command
  788. **/
  789. void SetVarFunc(struct ScriptLine *line)
  790. { 
  791.   struct 
  792.   {
  793.     STRPTR name;
  794.     STRPTR value;
  795.     ULONG global;
  796.     ULONG save;
  797.   } args;
  798.   int flags;
  799.  
  800.   args.name = NULL;
  801.   args.value = NULL;
  802.   args.global = FALSE;
  803.   args.save = FALSE;
  804.  
  805.   if (!(StrReadArgs(line->Args, (LONG *) &args,
  806.           (STRPTR) "NAME/A,VALUE/A,LOCALONLY/S,GLOBALONLY/S,SAVE/S")))
  807.   { 
  808.     fprintf(stderr, "Line %ld: Missing argument or memory error.\n",
  809.              line->Num);
  810.     exit(10);
  811.   }
  812.  
  813.   flags = 0;
  814.   if (args.save) 
  815.   {
  816.     flags |= GVF_SAVE_VAR;
  817.     args.global = TRUE;
  818.   }
  819.   if (args.global) 
  820.   {
  821.     flags |= GVF_GLOBAL_ONLY;
  822.   } 
  823.   else 
  824.   {
  825.     flags |= GVF_LOCAL_ONLY;
  826.   }
  827.  
  828.   setvar(args.name, args.value, LV_VAR|flags);
  829. }
  830. /**
  831. ***  This is the command table.
  832. **/
  833. struct Command CommandTab[] =
  834. { { EchoFunc,       (STRPTR) "echo"         },
  835.   { DeviceFunc,     (STRPTR) "device"       },
  836.   { SetFunc,        (STRPTR) "set"          },
  837.   { ShowParmsFunc,  (STRPTR) "showparms"    },
  838.   { SendFunc,       (STRPTR) "send"         },
  839.   { OnFunc,         (STRPTR) "on"           },
  840.   { WaitFunc,       (STRPTR) "wait"         },
  841.   { DelayFunc,      (STRPTR) "delay"        },
  842.   { ExitFunc,       (STRPTR) "exit"         },
  843.   { GotoFunc,       (STRPTR) "goto"         },
  844.   { TermFunc,       (STRPTR) "terminal"     },
  845.   { SystemFunc,     (STRPTR) "system"       },
  846.   { ScanFunc,       (STRPTR) "scan"         },
  847.   { SetVarFunc,     (STRPTR) "setvar"       },
  848.   { NULL,           NULL                    }
  849. };
  850. /**
  851. ***  This function is used to process the file. Rather easy,
  852. ***  isn't it? :-)
  853. **/
  854. VOID ProcessFile(VOID)
  855. { 
  856.   for(CurrentScriptLine = (struct ScriptLine *) ScriptLineList.mlh_Head;
  857.       CurrentScriptLine->mn.mln_Succ;
  858.       CurrentScriptLine = (struct ScriptLine *) CurrentScriptLine->mn.mln_Succ)
  859.   { 
  860.     (*CurrentScriptLine->CommFunc)(CurrentScriptLine);
  861.   }
  862. }
  863. /**
  864. ***  This function reads and parses the file.
  865. **/
  866. VOID ParseFile(STRPTR file)
  867. { 
  868.   FILE *fp;
  869.   STATIC UBYTE buffer[4096];
  870.   ULONG linenum = 0;
  871.   ULONG success = TRUE;
  872.  
  873.   if (!(fp = fopen((char *) file, "r")))
  874.   { 
  875.     fprintf(stderr, "Could not open %s for reading.\n", file);
  876.     exit(10);
  877.   }
  878.  
  879.   NewList((struct List *) &ScriptLineList);
  880.  
  881.   while(fgets((char *) buffer, sizeof(buffer), fp))
  882.   { 
  883.     ULONG len = strlen((char *) buffer);
  884.     STRPTR line;
  885.     STRPTR Label = NULL;
  886.     CommandFunc CommFunc;
  887.  
  888.     ++linenum;
  889.  
  890.     if (buffer[len-1] != '\n')
  891.     { 
  892.       fprintf(stderr, "Line %ld too long.\n", linenum);
  893.       exit(10);
  894.     }
  895.  
  896.     if (!(line = malloc(len+1)))
  897.     { 
  898.       perror("malloc");
  899.       exit(10);
  900.     }
  901.     strcpy((char*) line, (char*) buffer);
  902.     
  903.     line = SkipBlanks(line);
  904.  
  905.     /**
  906.     ***  Check for a label
  907.     **/
  908.     { 
  909.       STRPTR ptr = line;
  910.  
  911.       if (isalpha(*ptr))
  912.       { 
  913.         do
  914.           { 
  915.           ++ptr;
  916.           }
  917.           while(isalnum(*ptr));
  918.  
  919.           if (*ptr == ':')
  920.           { 
  921.           *ptr = '\0';
  922.             Label = line;
  923.             line = SkipBlanks(ptr+1);
  924.           }
  925.       }
  926.     }
  927.  
  928.     /**
  929.     ***  Check for empty line or comment line
  930.     **/
  931.     if (*line == ';'  ||  *line == '\r'  ||  *line == '\n')
  932.     { 
  933.       CommFunc = NoneFunc;
  934.       if (!Label)
  935.       { 
  936.         continue;
  937.       }
  938.     }
  939.  
  940.     /**
  941.     ***  If no empty line: Check for command
  942.     **/
  943.     else
  944.     { 
  945.       struct Command *comm;
  946.  
  947.       for (comm = &CommandTab[0];  comm->Func;  ++comm)
  948.       { 
  949.         ULONG len = strlen((char *) comm->Name);
  950.  
  951.           if (strnicmp((char *) comm->Name, (char *) line, len) == 0  &&
  952.              (line[len] == ' '  ||  line[len] == '\t'  ||
  953.               line[len] == '\r' ||  line[len] == '\n'))
  954.           { 
  955.           line = SkipBlanks(line+len);
  956.             CommFunc = comm->Func;
  957.             break;
  958.           }
  959.       }
  960.  
  961.       if (!comm->Func)
  962.       { 
  963.         fprintf(stderr, "Line %ld: Unknown command.\n", linenum);
  964.           success = FALSE;
  965.       }
  966.     }
  967.  
  968.     /**
  969.     ***  Allocate a new scriptline structure.
  970.     **/
  971.     { 
  972.       struct ScriptLine *sl;
  973.  
  974.       if (!(sl = malloc(sizeof(*sl))))
  975.       { 
  976.         perror("malloc");
  977.           exit(10);
  978.       }
  979.  
  980.       AddTail((struct List *) &ScriptLineList, (struct Node *) sl);
  981.       sl->Num = linenum;
  982.       sl->CommFunc = CommFunc;
  983.       sl->Args = line;
  984.       sl->Label = Label;
  985.       /*
  986.       if(VerboseMode)
  987.       {
  988.         printf("\n");
  989.         printf("ParseFile: Num      %d  \n", sl->Num);
  990.         printf("ParseFile: CommFunc 0x%x\n", sl->CommFunc);
  991.         printf("ParseFile: Args     %s  \n", sl->Args);
  992.         printf("ParseFile: Label    %s  \n", sl->Label);
  993.       }
  994.       */
  995.     }
  996.   }
  997.  
  998.   if (ferror(fp))
  999.   { 
  1000.     perror("fgets");
  1001.     exit(10);
  1002.   }
  1003.  
  1004.   if (!success)
  1005.   { 
  1006.     exit(10);
  1007.   }
  1008.  
  1009.   fclose(fp);
  1010. }
  1011. /**
  1012. ***  This is the Cleanup() function, called, when the program terminates.
  1013. **/
  1014. VOID Cleanup(VOID)
  1015. { 
  1016.   SerialCleanup();
  1017.   StrReadArgsFree();
  1018.   if (MainRDArgs)
  1019.   { 
  1020.     FreeArgs(MainRDArgs);
  1021.   }
  1022. }
  1023. /**
  1024. ***  This function hints about the GPL.
  1025. **/
  1026. VOID ShowGPL(FILE *fp)
  1027. { 
  1028.   fprintf(fp, "This program is governed by the terms and conditions of the\n");
  1029.   fprintf(fp, "GNU General Public License. A copy should have come with\n");
  1030.   fprintf(fp, "this distribution. (See the file COPYING.) In that license\n");
  1031.   fprintf(fp, "it is made clear that you are welcome to redistribute either\n");
  1032.   fprintf(fp, "verbatim or modified copies of the program and the documentation\n");
  1033.   fprintf(fp, "under certain conditions. Further you are told that this program\n");
  1034.   fprintf(fp, "comes with ABSOLUTELY NO WARRANTY!\n");
  1035. }
  1036. /**
  1037. ***  This function displays the Usage() message.
  1038. **/
  1039. VOID Usage(VOID)
  1040. { 
  1041.   fprintf(stderr, "Usage: IPDial SCRIPT,DEVICE/K,PROTOCOL/K,TERMINAL/S,ECHO/S,VERBOSE/S,HELP/S\n\n");
  1042.   fprintf(stderr, "\tSCRIPT:    Script file to execute.\n");
  1043.   fprintf(stderr, "\tDEVICE:    Device to use (default serial.device)\n");
  1044.   fprintf(stderr, "\tPROTOCOL:  Protocol to use; XONXOFF, 7WIRE (default) or NONE)\n");
  1045.   fprintf(stderr, "\tUNIT:      Unit to use (default 0)\n");
  1046.   fprintf(stderr, "\tECHO:      Show modems replies.\n");
  1047.   fprintf(stderr, "\tVERBOSE:   Be verbose.\n\n");
  1048.   fprintf(stderr, "\tTERMINAL:  Run in terminal mode.\n");
  1049.   fprintf(stderr, "\tHELP:      Print this message.\n");
  1050.   fprintf(stderr, "\n\n%s  @ 1994 by Jochen Wiedmann\n\n", VString);
  1051.   ShowGPL(stderr);
  1052.   exit(5);
  1053. }
  1054. /**
  1055. ***  This is main().
  1056. **/
  1057. int main(int argc, char *argv[])
  1058. { 
  1059.   struct
  1060.   { 
  1061.     STRPTR file;
  1062.     STRPTR device;
  1063.     STRPTR protocol;
  1064.     LONG *unit;
  1065.     LONG *baud;
  1066.     ULONG terminal;
  1067.     ULONG help;
  1068.     ULONG echo;
  1069.     ULONG verbose;
  1070.     ULONG raw;
  1071.   } args;
  1072.  
  1073.   args.file = NULL;
  1074.   args.device = (STRPTR) "serial.device";
  1075.   args.protocol = (STRPTR) "7wire";
  1076.   args.unit = NULL;
  1077.   args.baud = NULL;
  1078.   args.terminal = FALSE;
  1079.   args.echo = FALSE;
  1080.   args.verbose = FALSE;
  1081.   args.help = FALSE;
  1082.   args.raw = FALSE;
  1083.  
  1084.   if (!argc)    /*  No WB handling.     */
  1085.   { 
  1086.     exit(-1);
  1087.   }
  1088.  
  1089.   if (atexit(Cleanup))
  1090.   { 
  1091.     fprintf(stderr, "Memory error.\n");
  1092.     exit(20);
  1093.   }
  1094.  
  1095.   if (!(MainRDArgs = ReadArgs((STRPTR) "SCRIPT,DEVICE/K,PROTOCOL/K,"
  1096.                                            "UNIT/K/N,BAUD/K/N,TERMINAL/S,"
  1097.                                              "HELP/S,ECHO/S,VERBOSE/S,RAW/S",
  1098.                                               (LONG *) &args, NULL)))
  1099.   { 
  1100.     fprintf(stderr, "Cannot parse command line.\n");
  1101.   }
  1102.  
  1103.   if (args.help  || (!args.file  &&  !args.terminal))
  1104.   { 
  1105.     Usage();
  1106.   }
  1107.  
  1108.   EchoMode = args.echo;
  1109.   if (args.verbose)
  1110.   { 
  1111.     VerboseMode = TRUE;
  1112.     printf("%s  @ 1994 by Jochen Wiedmann\n\n", VString);
  1113.     ShowGPL(stdout);
  1114.     printf("\n\n");
  1115.   }
  1116.  
  1117.   if (args.terminal)
  1118.   { 
  1119.     if(VerboseMode)
  1120.       printf("\nMain: %d\n",__LINE__);
  1121.       
  1122.     SerialOpen(args.device, args.protocol, args.unit ? *args.unit : 0);
  1123.     if (args.baud)
  1124.     { 
  1125.       if(VerboseMode)
  1126.         printf("\nMain: %d\n",__LINE__);
  1127.       SerialSetBaud(*args.baud);
  1128.     }
  1129.     if(VerboseMode)
  1130.       printf("\nMain: %d\n",__LINE__);
  1131.     SerialTerminal(NULL, TRUE, !args.raw);
  1132.   }
  1133.   else if (args.file)
  1134.   { 
  1135.     if(VerboseMode)
  1136.       printf("\nMain: %d\n",__LINE__);
  1137.     ParseFile(args.file);
  1138.     if(VerboseMode)
  1139.       printf("\nMain: %d\n",__LINE__);
  1140.     ProcessFile();
  1141.   }
  1142.  
  1143.   exit(0);
  1144. }
  1145.